COMMENT ⊗   VALID 00004 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	Guide to getting along in SCORE
C00008 00003			INTERLISP
C00013 00004	RLL Itself
C00015 ENDMK
C⊗;
Guide to getting along in SCORE

1. Everyone has a fixed storage allocation -- SCORE will NOT let you
exceed this, not even temporarily.  Therefore, be sure you have the space
necesary for the new file before SYSOUTing, or even MAKEFILEing, ...
If not, and if SCORE gives a "?QUOTA EXCEEDED ..." message, you can try
EXPunging (this is a monitor level command).  If this frees up some pages,
typing CONTinue will return you to LISP.  Otherwise, you may have to play
some games - like renaming things to the (nearly infinite) 3SCRATCH directory
before continuing.  It IS a major hassle - but that's what we're paid for.

Further suggestion: Many commands, such as DIRectory, REName, EXPunge, etc,.
do NOT destroy your core image (that is, typing CONTinue after such a command
returns you to LISP).  Others, like the EMACS editor, ARE destructive!
You are advised, if in doubt, to first do a PUSH to get an inferior fork,
and work there if you intend to do anything complicated.  Afterward you can
POP back to you prior level, and CONTinue from here.

SET DIR GENeration-retention-count 3
( ↑ This is only for subsequent files; to take care of each current file:)
SET FIles GENeration-retention-count *.* 3

Other moditor level commands:
	The CONNect command
Typing "CONNect <CSD.RLL>↓" (where ↓ means carriage-return) connects you
to <CSD.RLL> -- that is, you can read/write/... any file stored there, as
if you had logged in on this account.
(Well, sorta. Actually CSD.RLL is a files-only account, so you couldn't have
logged on to it at all, but ...)
In general, after returning, SCORE would ask for the password of this account;
but this is (apparently) ommittable for the various <CSD.xxx> accounts,
where xxx is some files-only account, in the appropriate group (in our case,
HPP.)
[Until their rightful users begin using them, we can feel free to exploit the
space of other such accounts - such as <CSD.IA>.]

	The ACCESS command
Typing "ACCESS <CSD.GREINER>↓" then my password, gives you access to everything
the  CSD.GREINER account could have accessed.
That is, while you are still connected to your current account,
you are now considered to be in the same group as GREINER; and as such may
connect to/read/write/... anything he could of.
(It is as if you would have had you logged on as GREINER.)
Note this does NOT work for Files-Only accounts.

LISP gets INTERLISP (MACLISP for guess what)
Eventually you will need to type RLL to get RLL, CORLL for CORLL, MRS for MRS.
Currently you have to actually type <CSD.RLL>name for each such name.
(This runs the file name.EXE, which is a SYSOUT made from LISP.)

Actually, RLL.EXE may or may not exist. The procedure for creating it
appears in the next section.

	Changes to make to various files:
LOGIN.CMD file. (This file is executed each time you log in.)

1) Set PATH - this indicates which directories to check to find a given name.
Certainly it should go thru <CSD.RLL>;
You might want to also go thru <CSD.GREINER>, <CSD.SMITH> or <CSD.LENAT>, maybe.
2) Set the EDITOR -- to, e.g. EMACS.
3) Indicate you are (probably) logging on using a Heath-19, or Datamedia, etc.

Various other initialization files are:
EMACS.INIT - see Mike Genesereth (or other EMACS hacker) to understand what goes
	here.
LISP.INIT - executed on entry to LISP - note NOT called when entering a sysout,
	which had been created using LISP.

Ask ADMIN.MRC for reference manual. In case of emergency, feel free to
ask me or someone else. (Eg CSD.SMITH, CSD.BENNETT, or ADMIN.* for any *.)
		INTERLISP
LISP's evaluator takes an S-Expression, evaluates it, and prints the result.
Typing a closing parenthesis causes the reader to return, and begins
the evaluation. (The other way is to type a simple atom, and return.)
Note there are SuperParentheses, "[]" which are sorta like the vanilla
"()", but: A closing "]" matches as many opening "("s as necessary to reach
either the beginning of the line, or the next not yet matched "[".

The evaluator is a bit cleverer - so typing FN(arg1 arg2), at the TOP level only,
is the same as (FN 'arg1 'arg2).
It will also try various spelling corrections, (based on list of expressions
you have already typed this session).

Useful commands:
(DEFINEQ (fn (arg1 arg2) (sexpr1) ... )) defines a function, fn, as a lambda
	expression taking two args (bound to names arg1 and arg2), and ...
(SETQ name val) - sets the value cell of the atom name to the value "val".
	(Only 2nd argument is evaluated.)
RPLACA, RPLACD...
LOAD(filename)  - reads in the contents of the file, filename.
	[If name is of the form EURISKO, that source code file is read in;
	 EURISKO.COM is the associated compiled file.]
MAKEFILE(filename params)  - writes out the contents of the file, filename.
	Note the function edits, variable resetting, etc. you make will be lost
	if you simply LOGOUT) from LISP, unless you have explicitly remade the
	files you changed (or SYSOUTed).
	Many utilities, such as FILES?] and CLEANUP], are designed to
	facilitate this storage process.
SYSOUT(name) - creates an *.EXE file, which may be reentered.
LOGOUT) - same as typing ↑C. (See below.)

Control Characters:
↑H - this is the weakest interrupt - breaks before next function call.
↑E - this interrupts immediately after saving state. This is fairly safe.
↑D - this interrupts immediately, period. You might get screwed if you're,
	for example, in the middle of a garbage collection.
↑B - ?
↑C - leaves INTERLISP - back to the monitor. CONTinue returns you to LISP.
↑N - during input, this tells the evaluator NOT to evaluate the expression you
	are now typing -- rather, you are now permitted to EDIT this form.
	That modified expression will then be executed.

Bells and whistles:
EDITOR - although archaic, this should be learned. One can use this S-expression
	editor to redefine functions, modify an atom's propertie list or alter
	an atom's value.
	(See EDITF, EDITP and EDITV, respectively.)
	RLL includes an analogous feature for editing the value of a unit, EDITU.

BREAK, TRACE package - see manual.

HISTORYLIST - LISP stores the commands and effects of the last 20 commands.
	One can, for example, REDO an earlier command, edit an earlier command
	to a different form and execute that version, or UNDO many commands.
	(For example, one can UNDO a LOAD command! Pretty snazzy...)

All these things, and a tremendous amount more, can be found in the INTERLISP
manual.
RLL Itself
If not RLL.EXE SYSOUT exists, it can be created by:
	First type 
<CSD.RLL>CORLL
	to the monitor
	(the directory name is needed only if the directory is NOT on your
	 path, or if another one would have intercepted this one.)
	You are now, essentially, in LISP.
	Next 
LOAD(<CSD.RLL>UTIL.COM)
	- the directory may be omittable, as before -
	This reads in the essential stuff. Then
	[To create a RLL sysout, at this point, type "SYSOUT(RLL]".]
START]
	gets things going.
This reads in the files/KBs, asks what other KBs you want, gets them, and
on completion, dumps you in LISP.

More can be found in the "Details of RLL-1" paper, and Smith's "CORLL" document.